格物志

格物致知 知行合一

0%

文件操作、IO流

发表于 更新于 分类于
本文字数： 4.7k 阅读时长 ≈ 4 分钟

一，File

1.1 概念

概念：文件和目录路径名的抽象表示形式。

1.2 构造函数

  1. new File(String path)
  2. new File(File parent，String path)
  3. new File(String parent，String path)

字段摘要：

File.separator：与系统有关的默认名称分隔符，为了方便，它被表示为一个字符串。

1.3 常用方法

1.3.1 创建和删除
  1. createNewFile()：如果指定文件不存在，则创建一个指定文件名的文件，返回 true；如果已存在，则不创建，返回 false
  2. mkdir()：创建一个文件夹（只能创建单层目录），返回 false 表示创建失败，true 表示成功
  3. mkdirs()：创建一个文件夹（可以创建多级目录），返回 false 表示创建失败，true 表示成功
  4. delete()：删除文件或者文件夹，，返回 false 表示删除失败，true 表示成功，如果文件夹中含有内容，那么该文件夹不能删除
  5. deleteOnExit()：删除文件或者文件夹，在程序运行完毕后执行该删除操作，如果文件夹中含有内容，那么该文件夹不能删除
1.3.2 判断相关
  1. exists()：判断文件或者文件夹是否存在
  2. isFile()：判断是否是文件
  3. isDirectory()：判断是否是目录

注：如果文件或者文件夹不存在，那么无论是判断是文件还是目录返回的都是 false

  1. canRead()：判断是否可读
  2. canWrite()：判断是否可写
  3. canExecute()：判断是否可执行，只有 linux 操作系统下有效
  4. isHidden()：判断文件或者文件夹是否隐藏
1.3.3 获取相关
  1. getPath()：获取路径，返回结果与创建时的路径表示形式相同
  2. getAbsolutePath()：获取绝对路径，无论创建时使用的是相对路径还是绝对路径，返回的都是绝对路径
  3. getParent()：返回父目录的地址，如果是以相对路径的写法创建文件对象，那么返回的结果是null
  4. getParentFile()：返回父目录文件的对象
  5. getName()：返回文件名（包含后缀）
  6. length()：返回文件大小，单位是字节
1.3.4 遍历目录
  1. list()：返回指定目录下所有文件或者文件夹的名字组成的数组
  2. listFiles()：返回指定目录下所有文件对象组成的数组
  3. list(FilenameFilter filter)：根据指定的文件名过滤器获取指定文件，将它们的名字组成数组
  4. listFile(FilenameFilter filter)：根据指定的文件名过滤器获取指定文件，将这些文件对象组成数组

1.4 文件过滤

  1. 实现 FileNameFilter 接口

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    class MyFilter implements FilenameFilter{
    	/*
    	 * 参数：
    	 * 1.dir：调用listFiles的目录对象
    	 * 2.name：当前目录下的所有文件的文件名
    	 */
    	@Override
    	public boolean accept(File dir, String name) {
    		return name.endsWith("mp3")||name.endsWith("wma");
    	}
    }

  2. 实现 FileFilter 接口

    1
    2
    3
    4
    5
    6
    7
    File[] fss = f.listFiles(new FileFilter(){
        @Override
        public boolean accept(File pathname) {
            return pathname.getName().endsWith("txt");
        }
    });
    System.out.println(fss.length);

1.5 目录的遍历（递归）

递归：在方法中直接或者间接的调用自身

注：

  1. 递归要有结束的条件，保证递归能够停止，否则会发生 StackOverflowError 栈溢出
  2. 在不断递归的过程中，数据规模要不断减小
  3. 递归的性能较差
1
2
3
4
5
6
7
8
9
10
11
public static void search(File dir){
    for (File file : dir.listFiles()) {
        if(file.isFile()){
            if(file.getName().endsWith("txt")){
                fileList.add(file);
            }
        }else{
            search(file);
        }
    }
}

二，IO流

2.1 什么是IO流

我们把数据的传输看成是一种数据的流动，按照流向进行划分分为输入流（input）和输出流（output）

IO流的分类

根据数据的流向划分：

  1. 输入流：把数据从其他设备读取到内存中（外 -> 内）
  2. 输出流：把数据从内存中写到其他设备上（内 -> 外）

根据数据的类型划分：

  1. 字节流：以字节为单位，任何文件
  2. 字符流：以字符为单位，文本文件>

IO流的顶层父类（抽象类）

  1. 字节输入流：InputStream
  2. 字节输出流：OutputStream
  3. 字符输入流：Reader
  4. 字符输出流：Writer

2.2 FileOutputStream 文件字节输出流

构造方法：

  1. new FileOutputStream(File f)：根据指定文件对象所指向的文件路径创建文件字节输出流对象
  2. new FileOutputStream(String name)：根据指定文件路径创建文件字节输出流对象
  3. new FileOutputStream(File f，boolean b)：功能同上，第二个参数值为 true 时，表示该文件可以续写
  4. new FileOutputStream(String name，boolean b)：功能同上，第二个参数值为 true 时，表示该文件可以续写

常用方法：

  1. close()：释放资源，如果执行了 close() 方法，那么就不能在写入了
  2. flush()：刷新缓冲区
  3. write(int ch)：根据十进制数写入对应的字符
  4. writer(byte[] b)：写入指定的字节数组，如果要写入字符串，可以通过，字符串的 getBytes() 方法获取对应的字节数组
  5. writer(byte[] b，int index ，int lenth)：从字节数组中的指定位置获取指定数量的元素写入到文件中

2.3 FileInputStream 文件字节输入流

构造函数

  1. new FileInputStream(File f)：根据指定文件对象所指向的文件路径创建文件字节输入流对象
  2. new FileInputStream(String name)：根据指定文件路径创建文件字节输入流对象

常用方法

  1. read()：读取单个字符所对应的十进制数，返回 -1 表示读完了
  2. read(byte b[]，int a，int b)：从指定文件中的a位置开始，读取b个字符，存储到数组中
  3. read(byte b[])：从指定文件中读取还未获取到的字符，存储到数组中，返回读取到的有效个数
  4. close()：释放资源

2.4 FileWriter 文件字符输出流

构造函数

  1. new FileWriter(File f)
  2. new FileWriter(String name)
  3. new FileWriter(File f，boolean b)
  4. new FileWriter(String name，boolean b)

常用方法

  1. close()：释放资源，执行释放动作前，会先将缓冲区中的数据刷新到的目标位置
  2. flush()：当使用 write() 方法写入文件时，只是把数据写入到了缓冲区中，需要用 flush() 才能将数据从缓冲区中真正的刷新到目标位置
  3. write(int ch)
  4. write(String str)
  5. write(String str，int index，int length)
  6. write(char[] ch)
  7. write(char[] ch，int index，int length)

2.5 FileReader 文件字符输入流

构造函数

  1. new FileReader(File f)
  2. new FileReader(String name)

常用方法

  1. read()
  2. read(char ch[])
  3. read(char ch[] ，int index，int lenth)
  4. close()

2.6 缓冲流

概念：也称作高效流，它是对文件流的增强

效率高的原因：在进行IO操作时，内置一个缓冲区数组，通过缓冲区数组来减少对文件的IO操作次数，从而提高效率。

分类：

  1. BufferedReader：字符缓冲输入流
  2. BufferedWriter：字符缓冲输出流
  3. BufferedInputStream：字节缓冲输入流
  4. BufferedOutputStream：字节缓冲输出流

构造方法

1
2
3
4
5
6
7
BufferedReader br = new BufferedReader(Reader r);

BufferedWriter bw = new BufferedWriter(Writer w);

BufferedInputStream bis = new BufferedInputStream(InputStream is);

BufferedOutputStream bos = new BufferedOutputStream(OutputStream os);

方法：缓冲流中的方法和普通文件流中的方法相同

特有方法：

  1. BufferedReader 中 readLine()：读取一整行
  2. BufferedWriter 中 newLine()：写入一个换行

2.7 对象流（序列化流）

Java 中提供了一种对象的序列化机制，允许将一个对象及其属性持久化到文件中

序列化：将对象存储到文件中

反序列化：将文件中的对象解析出来

ObjectOutputStream

构造函数：new ObjectOuputStream(OutputStream os)

ObjectInputStream

构造函数：new new ObjectInputStream(InputStream is);

1
2
3
4
5
6
7
8
9
10
11
12
13
Emp e = new Emp();
e.setName("张三");
e.setAge(20);

FileOutputStream fos = new FileOutputStream("C:\\Users\\86151\\Desktop\\test\\d.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(e);

FileInputStream fis = new FileInputStream("C:\\Users\\86151\\Desktop\\test\\d.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
Emp emp = (Emp)ois.readObject();
System.out.println(emp.getName());
System.out.println(emp.getAge());

注：

  1. 一个类的对象要被序列化，该类必须实现 Serializable ，该接口是一个标记接口，不需要重写方法，否则会发生 NotSerializableException
  2. 如果读取对象的次数超过了对象的个数会发生 EOFException
  3. 如果不想让某个属性被序列化，需要使用关键字transient(瞬态的)
222222222